{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### 特征工程\n",
    "- 是将原始数据转换为更好地代表预测模型的潜在问题的特征的过程，从而提高了模型对未知数据预测的准确性\n",
    "\n",
    "- 意义：直接影响模型的预测结果"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T01:07:16.936257Z",
     "start_time": "2025-01-20T01:07:14.453209Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    # 矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    # Vectorizer中文含义是矢量器\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为False看看(False是one)\n",
    "    dict2 = DictVectorizer(sparse=False)\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    print(dict2.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}]))\n",
    "    print('-' * 50)\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)  # 存稀疏编码，降低了空间占用，但实际运算不能用稀疏编码，得转成ndarray\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())  # 输出每个特征的名称（one-hot编码的特征名称）\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T01:07:16.948631Z",
     "start_time": "2025-01-20T01:07:16.937247Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.   1.   0. 100.]\n",
      " [  1.   0.   0.  60.]\n",
      " [  0.   0.   1.  30.]]\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": "# 2 一段英文文本如何变为数值类型",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果，把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T01:07:16.957047Z",
     "start_time": "2025-01-20T01:07:16.949621Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T01:17:00.388656Z",
     "start_time": "2025-01-20T01:17:00.382188Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "    print('*'*50)\n",
    "    return c1, c2, c3\n",
    "\n",
    "cutword()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T01:45:11.768487Z",
     "start_time": "2025-01-20T01:45:11.761729Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "**************************************************\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。',\n",
       " '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。',\n",
       " '如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T01:45:26.727284Z",
     "start_time": "2025-01-20T01:45:26.720990Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "hanzivec()"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "**************************************************\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf\n",
    "- 主要思想：如果某个词或短语在一篇文章中出现的概率高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。\n",
    "- 作用：用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。\n",
    "- 类：sklearn.feature_extraction.text.TfidfVectorizer\n",
    "Tf:term frequency:词的频率出现的次数\n",
    "\n",
    "idf:逆文档频率inverse document frequency\n",
    "\n",
    "log(总文档数量/该词出现的文档数量)  以10为低\n",
    "\n",
    "tf*idf  来代表重要性程度:\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "    print(c1, c2, c3)\n",
    "    print('-' * 50)\n",
    "    # print(type([c1, c2, c3])) # list\n",
    "    # 平滑的目的：防止一个词的IDF分母为0（同时+1）防止零分裂\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T05:42:26.822675Z",
     "start_time": "2025-01-20T05:42:26.815391Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "**************************************************\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "<class 'list'>\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T05:56:34.973741Z",
     "start_time": "2025-01-20T05:56:34.967761Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\"\"\"\n",
    "归一化\n",
    "- 特点：通过对原始数据进行变换把数据映射到(默认为[0,1])之间\n",
    "- 公式：𝑋′=  (𝑥−𝑚𝑖𝑛)/(𝑚𝑎𝑥−𝑚𝑖𝑛)  𝑋′′=𝑋′∗(𝑚𝑥−𝑚𝑖)+𝑚𝑖\n",
    "注：作用于每一列，max为一列的最大值，min为一列的最小值,那么X’’为最终结果，mx，mi分别为指定区间值默认mx为1,mi为0\n",
    "- 优点：容易更快地通过梯度下降找到最优解\n",
    "\n",
    "- 缺点：在特定场景下最大值最小值是变化的，另外，最大值与最小值非常容易受异常点影响，所以这种方法鲁棒性较差，只适合传统精确小数据（样本量小）场景。\n",
    "\"\"\""
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'归一化\\n- 特点：通过对原始数据进行变换把数据映射到(默认为[0,1])之间\\n- 公式：𝑋′=  (𝑥−𝑚𝑖𝑛)/(𝑚𝑎𝑥−𝑚𝑖𝑛)  𝑋′′=𝑋′∗(𝑚𝑥−𝑚𝑖)+𝑚𝑖\\n\\n注：作用于每一列，max为一列的最大值，min为一列的最小值,那么X’’为最终结果，mx，mi分别为指定区间值默认mx为1,mi为0\\n- 缺点：容易受极值的影响；容易受异常值的影响\\n'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])  # 测试机：由于训练时已经fit_transform过，这里不fit直接带入，可能出错出现负值\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T05:46:33.200666Z",
     "start_time": "2025-01-20T05:46:33.190551Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": "(1 - 60) / 30",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-20T05:59:02.157108Z",
     "start_time": "2025-01-20T05:59:02.150624Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "\"\"\"\n",
    "标准化：\n",
    "1、特点：通过对原始数据进行变换把数据变换到均值为0,标准差为1范围内\n",
    "不是标准正态分布，只是均值为0，标准差为1的分布（分布与之前保持一致）\n",
    "2、公式：𝑋′=  (x−mean)/𝜎\n",
    "注：作用于每一列，mean为平均值，𝜎为标准差(考量数据的稳定性)\n",
    "var成为方差，𝑣𝑎𝑟=  ((𝑥1−𝑚𝑒𝑎𝑛)^2+(𝑥2−𝑚𝑒𝑎𝑛)^2+…)/(𝑛(每个特征的样本数))，𝜎= √𝑣𝑎𝑟\n",
    "3.对于标准化来说：如果出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响并不大，从而方差改变较小。\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T06:01:45.243999Z",
     "start_time": "2025-01-20T06:01:45.236179Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T06:12:25.098470Z",
     "start_time": "2025-01-20T06:12:25.093681Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-20T06:20:37.597549Z",
     "start_time": "2025-01-20T06:20:37.593562Z"
    }
   },
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 23
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-20T06:12:32.437373Z",
     "start_time": "2025-01-20T06:12:32.433719Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-20T06:12:35.245348Z",
     "start_time": "2025-01-20T06:12:35.240741Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "markdown",
   "source": "## transform和fit_transform不同：transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差",
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n",
    "1. 删除：如果每列或者行数据缺失值达到一定的比例，建议放弃整行或者整列\n",
    "2. 填补：可以通过缺失值每行或者每列的平均值、中位数、众数来填充\n",
    "- sklearn缺失值API：from sklearn.impute import SimpleImputer\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    # mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T06:26:57.407521Z",
     "start_time": "2025-01-20T06:26:57.401617Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "source": "11 / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-20T06:27:02.953666Z",
     "start_time": "2025-01-20T06:27:02.949856Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 26
  },
  {
   "cell_type": "code",
   "source": "np.nan + 10",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-20T06:27:04.808991Z",
     "start_time": "2025-01-20T06:27:04.804841Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 27
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 特征选择\n",
    "原因：\n",
    "1. 冗余：部分特征的相关度高，容易消耗计算性能\n",
    "    - 两个特征：一个身高 cm，一个高矮类别：没必要用两个\n",
    "2. 噪声：部分特征对预测结果有负影响\n",
    "\n",
    "是什么：\n",
    "- 特征选择就是单纯地从提取到的所有特征中选择部分特征作为训练集特征，\n",
    "- 特征在选择前和选择后可以改变值、也可以不改变值，但是选择后的特征维数肯定比选择前小，毕竟我们只选择了其中的一部分特征。\n",
    "\n",
    "方法：\n",
    "1. Filter(过滤式):VarianceThreshold\n",
    "2. Embedded(嵌入式)：正则化、决策树\n",
    "3. Wrapper(包裹式)   集成学习\n",
    "- 掌握前两种\n"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 包裹式（Wrapper）特征选择方法\n",
    "- 是基于模型的性能来选择特征，它将特征选择看作是一个搜索问题，通过评估不同特征子集上模型的性能来选择最优的特征子集。\n",
    "- 常见的包裹式特征选择方法如下：\n",
    "    1. 递归特征消除（Recursive Feature Elimination，RFE）\n",
    "        - 原理：从包含所有特征的集合开始，递归地移除对模型性能贡献最小的特征。每次迭代都会训练一个模型，然后根据模型的系数或特征重要性（后面算法会涉及）等指标，确定要移除的特征，直到达到预设的特征数量或模型性能不再提升。\n",
    "    2. 顺序特征选择（Sequential Feature Selection, SFS）\n",
    "        - 这种方法通过逐步添加或移除特征来构建特征子集。常见的有前向选择（Sequential Forward Selection, SFS）和后向选择（Sequential Backward Selection, SBS）。前向选择从空集开始，逐步添加特征；后向选择从全集开始，逐步移除特征。\n",
    "    3. 遗传算法（Genetic Algorithm）：\n",
    "        - 这是一种基于生物进化理论的优化算法，通过模拟自然选择的过程来选择特征子集。它通过交叉、变异等操作来生成新的特征子集，并根据模型性能来评估这些子集。\n",
    "    4. Las Vegas Wrapper（LVW）：这种方法使用随机策略来进行特征子集的搜索，并以模型的误差作为特征子集的评价标准。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维（Filter(过滤式):VarianceThreshold）\n",
    "- 降维就是特征数变少\n",
    "- 降维可以提高模型训练速度（特征变少）\n",
    "- 特征选择API：sklearn.feature_selection.VarianceThreshold\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择：删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T06:36:23.785174Z",
     "start_time": "2025-01-20T06:36:23.776692Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 28
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# PCA\n",
    "1. 本质：PCA是一种分析、简化数据集的技术\n",
    "2. 目的：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。\n",
    "3. 作用：可以削减回归分析或者聚类分析中特征的数量\n",
    "- PCA :特征数量达到上百的时候，开始使用PCA\n",
    "\n",
    "PCA (Principal ComponentAnalysis，主成分分析)的结果可能会因为以下几个原因而不稳定:\n",
    "- 数据归一化的方式不同:对于PCA来说，数据的归一化可以采用标准化或者最大最小值归一化等方法。不同的归—化方式会导致不同的结果。\n",
    "- 特征值计算的精度:在特征值计算算精度也可能会影响结果的稳定性。\n",
    "- 特征值相同时的特征向量计算:特征向量的计算就不唯一了,不同的计算方式也会导致结果不同。\n",
    "- 随机选择初始向量:在迭代计算特征向量的过程中，需要随机选择一个初始向量，这也可能会导致结果不稳定。\n",
    "- 为了提高结果的稳定性，可以采用多次运行PCA并取平均值的方法。另外，在进行PCA之前，可以对数据进行多次重复采样，然后对每次采样得到的数据进行PCA分析，以进一步提高结果的可靠性。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维（PCA）\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    \n",
    "    pca = PCA(n_components=0.99)  # 保留99%的方差\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-20T07:09:04.964604Z",
     "start_time": "2025-01-20T07:09:04.945124Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-3.13587302e-16  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333346\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 29
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "data": {
      "text/plain": "0.7499999999999999"
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": "22 / 29.333333333333336",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T03:08:17.259124100Z",
     "start_time": "2024-07-11T03:08:17.248038900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  # 每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-20T07:30:03.350751Z",
     "start_time": "2025-01-20T07:30:02.175505Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 31
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
